/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package entityprojet;

import entityprojet.exceptions.IllegalOrphanException;
import entityprojet.exceptions.NonexistentEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author T.Ron
 */
public class ComptegJpaController implements Serializable {

    public ComptegJpaController() {
        
    }
    private EntityManagerFactory emf = Persistence.createEntityManagerFactory("projetT_RPU");

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Compteg compteg) {
        if (compteg.getCompteaCollection() == null) {
            compteg.setCompteaCollection(new ArrayList<Comptea>());
        }
        if (compteg.getComptetCollection() == null) {
            compteg.setComptetCollection(new ArrayList<Comptet>());
        }
        if (compteg.getTaxeCollection() == null) {
            compteg.setTaxeCollection(new ArrayList<Taxe>());
        }
        if (compteg.getEcriturecCollection() == null) {
            compteg.setEcriturecCollection(new ArrayList<Ecriturec>());
        }
        if (compteg.getBudgetcgpbCollection() == null) {
            compteg.setBudgetcgpbCollection(new ArrayList<Budgetcgpb>());
        }
        if (compteg.getTaxeCollection1() == null) {
            compteg.setTaxeCollection1(new ArrayList<Taxe>());
        }
        if (compteg.getComptetCollection1() == null) {
            compteg.setComptetCollection1(new ArrayList<Comptet>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Taxe idTaxe = compteg.getIdTaxe();
            if (idTaxe != null) {
                idTaxe = em.getReference(idTaxe.getClass(), idTaxe.getIdTaxe());
                compteg.setIdTaxe(idTaxe);
            }
            Naturecg numnaturecg = compteg.getNumnaturecg();
            if (numnaturecg != null) {
                numnaturecg = em.getReference(numnaturecg.getClass(), numnaturecg.getNumnaturecg());
                compteg.setNumnaturecg(numnaturecg);
            }
            Compter idCr = compteg.getIdCr();
            if (idCr != null) {
                idCr = em.getReference(idCr.getClass(), idCr.getIdCr());
                compteg.setIdCr(idCr);
            }
            Collection<Comptea> attachedCompteaCollection = new ArrayList<Comptea>();
            for (Comptea compteaCollectionCompteaToAttach : compteg.getCompteaCollection()) {
                compteaCollectionCompteaToAttach = em.getReference(compteaCollectionCompteaToAttach.getClass(), compteaCollectionCompteaToAttach.getIdCa());
                attachedCompteaCollection.add(compteaCollectionCompteaToAttach);
            }
            compteg.setCompteaCollection(attachedCompteaCollection);
            Collection<Comptet> attachedComptetCollection = new ArrayList<Comptet>();
            for (Comptet comptetCollectionComptetToAttach : compteg.getComptetCollection()) {
                comptetCollectionComptetToAttach = em.getReference(comptetCollectionComptetToAttach.getClass(), comptetCollectionComptetToAttach.getIdCt());
                attachedComptetCollection.add(comptetCollectionComptetToAttach);
            }
            compteg.setComptetCollection(attachedComptetCollection);
            Collection<Taxe> attachedTaxeCollection = new ArrayList<Taxe>();
            for (Taxe taxeCollectionTaxeToAttach : compteg.getTaxeCollection()) {
                taxeCollectionTaxeToAttach = em.getReference(taxeCollectionTaxeToAttach.getClass(), taxeCollectionTaxeToAttach.getIdTaxe());
                attachedTaxeCollection.add(taxeCollectionTaxeToAttach);
            }
            compteg.setTaxeCollection(attachedTaxeCollection);
            Collection<Ecriturec> attachedEcriturecCollection = new ArrayList<Ecriturec>();
            for (Ecriturec ecriturecCollectionEcriturecToAttach : compteg.getEcriturecCollection()) {
                ecriturecCollectionEcriturecToAttach = em.getReference(ecriturecCollectionEcriturecToAttach.getClass(), ecriturecCollectionEcriturecToAttach.getIdEc());
                attachedEcriturecCollection.add(ecriturecCollectionEcriturecToAttach);
            }
            compteg.setEcriturecCollection(attachedEcriturecCollection);
            Collection<Budgetcgpb> attachedBudgetcgpbCollection = new ArrayList<Budgetcgpb>();
            for (Budgetcgpb budgetcgpbCollectionBudgetcgpbToAttach : compteg.getBudgetcgpbCollection()) {
                budgetcgpbCollectionBudgetcgpbToAttach = em.getReference(budgetcgpbCollectionBudgetcgpbToAttach.getClass(), budgetcgpbCollectionBudgetcgpbToAttach.getBudgetcgpbPK());
                attachedBudgetcgpbCollection.add(budgetcgpbCollectionBudgetcgpbToAttach);
            }
            compteg.setBudgetcgpbCollection(attachedBudgetcgpbCollection);
            Collection<Taxe> attachedTaxeCollection1 = new ArrayList<Taxe>();
            for (Taxe taxeCollection1TaxeToAttach : compteg.getTaxeCollection1()) {
                taxeCollection1TaxeToAttach = em.getReference(taxeCollection1TaxeToAttach.getClass(), taxeCollection1TaxeToAttach.getIdTaxe());
                attachedTaxeCollection1.add(taxeCollection1TaxeToAttach);
            }
            compteg.setTaxeCollection1(attachedTaxeCollection1);
            Collection<Comptet> attachedComptetCollection1 = new ArrayList<Comptet>();
            for (Comptet comptetCollection1ComptetToAttach : compteg.getComptetCollection1()) {
                comptetCollection1ComptetToAttach = em.getReference(comptetCollection1ComptetToAttach.getClass(), comptetCollection1ComptetToAttach.getIdCt());
                attachedComptetCollection1.add(comptetCollection1ComptetToAttach);
            }
            compteg.setComptetCollection1(attachedComptetCollection1);
            em.persist(compteg);
            if (idTaxe != null) {
                idTaxe.getComptegCollection().add(compteg);
                idTaxe = em.merge(idTaxe);
            }
            if (numnaturecg != null) {
                numnaturecg.getComptegCollection().add(compteg);
                numnaturecg = em.merge(numnaturecg);
            }
            if (idCr != null) {
                idCr.getComptegCollection().add(compteg);
                idCr = em.merge(idCr);
            }
            for (Comptea compteaCollectionComptea : compteg.getCompteaCollection()) {
                compteaCollectionComptea.getComptegCollection().add(compteg);
                compteaCollectionComptea = em.merge(compteaCollectionComptea);
            }
            for (Comptet comptetCollectionComptet : compteg.getComptetCollection()) {
                comptetCollectionComptet.getComptegCollection().add(compteg);
                comptetCollectionComptet = em.merge(comptetCollectionComptet);
            }
            for (Taxe taxeCollectionTaxe : compteg.getTaxeCollection()) {
                taxeCollectionTaxe.getComptegCollection().add(compteg);
                taxeCollectionTaxe = em.merge(taxeCollectionTaxe);
            }
            for (Ecriturec ecriturecCollectionEcriturec : compteg.getEcriturecCollection()) {
                Compteg oldIdCgOfEcriturecCollectionEcriturec = ecriturecCollectionEcriturec.getIdCg();
                ecriturecCollectionEcriturec.setIdCg(compteg);
                ecriturecCollectionEcriturec = em.merge(ecriturecCollectionEcriturec);
                if (oldIdCgOfEcriturecCollectionEcriturec != null) {
                    oldIdCgOfEcriturecCollectionEcriturec.getEcriturecCollection().remove(ecriturecCollectionEcriturec);
                    oldIdCgOfEcriturecCollectionEcriturec = em.merge(oldIdCgOfEcriturecCollectionEcriturec);
                }
            }
            for (Budgetcgpb budgetcgpbCollectionBudgetcgpb : compteg.getBudgetcgpbCollection()) {
                Compteg oldComptegOfBudgetcgpbCollectionBudgetcgpb = budgetcgpbCollectionBudgetcgpb.getCompteg();
                budgetcgpbCollectionBudgetcgpb.setCompteg(compteg);
                budgetcgpbCollectionBudgetcgpb = em.merge(budgetcgpbCollectionBudgetcgpb);
                if (oldComptegOfBudgetcgpbCollectionBudgetcgpb != null) {
                    oldComptegOfBudgetcgpbCollectionBudgetcgpb.getBudgetcgpbCollection().remove(budgetcgpbCollectionBudgetcgpb);
                    oldComptegOfBudgetcgpbCollectionBudgetcgpb = em.merge(oldComptegOfBudgetcgpbCollectionBudgetcgpb);
                }
            }
            for (Taxe taxeCollection1Taxe : compteg.getTaxeCollection1()) {
                Compteg oldIdCgOfTaxeCollection1Taxe = taxeCollection1Taxe.getIdCg();
                taxeCollection1Taxe.setIdCg(compteg);
                taxeCollection1Taxe = em.merge(taxeCollection1Taxe);
                if (oldIdCgOfTaxeCollection1Taxe != null) {
                    oldIdCgOfTaxeCollection1Taxe.getTaxeCollection1().remove(taxeCollection1Taxe);
                    oldIdCgOfTaxeCollection1Taxe = em.merge(oldIdCgOfTaxeCollection1Taxe);
                }
            }
            for (Comptet comptetCollection1Comptet : compteg.getComptetCollection1()) {
                Compteg oldNumcgPOfComptetCollection1Comptet = comptetCollection1Comptet.getNumcgP();
                comptetCollection1Comptet.setNumcgP(compteg);
                comptetCollection1Comptet = em.merge(comptetCollection1Comptet);
                if (oldNumcgPOfComptetCollection1Comptet != null) {
                    oldNumcgPOfComptetCollection1Comptet.getComptetCollection1().remove(comptetCollection1Comptet);
                    oldNumcgPOfComptetCollection1Comptet = em.merge(oldNumcgPOfComptetCollection1Comptet);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Compteg compteg) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Compteg persistentCompteg = em.find(Compteg.class, compteg.getIdCg());
            Taxe idTaxeOld = persistentCompteg.getIdTaxe();
            Taxe idTaxeNew = compteg.getIdTaxe();
            Naturecg numnaturecgOld = persistentCompteg.getNumnaturecg();
            Naturecg numnaturecgNew = compteg.getNumnaturecg();
            Compter idCrOld = persistentCompteg.getIdCr();
            Compter idCrNew = compteg.getIdCr();
            Collection<Comptea> compteaCollectionOld = persistentCompteg.getCompteaCollection();
            Collection<Comptea> compteaCollectionNew = compteg.getCompteaCollection();
            Collection<Comptet> comptetCollectionOld = persistentCompteg.getComptetCollection();
            Collection<Comptet> comptetCollectionNew = compteg.getComptetCollection();
            Collection<Taxe> taxeCollectionOld = persistentCompteg.getTaxeCollection();
            Collection<Taxe> taxeCollectionNew = compteg.getTaxeCollection();
            Collection<Ecriturec> ecriturecCollectionOld = persistentCompteg.getEcriturecCollection();
            Collection<Ecriturec> ecriturecCollectionNew = compteg.getEcriturecCollection();
            Collection<Budgetcgpb> budgetcgpbCollectionOld = persistentCompteg.getBudgetcgpbCollection();
            Collection<Budgetcgpb> budgetcgpbCollectionNew = compteg.getBudgetcgpbCollection();
            Collection<Taxe> taxeCollection1Old = persistentCompteg.getTaxeCollection1();
            Collection<Taxe> taxeCollection1New = compteg.getTaxeCollection1();
            Collection<Comptet> comptetCollection1Old = persistentCompteg.getComptetCollection1();
            Collection<Comptet> comptetCollection1New = compteg.getComptetCollection1();
            List<String> illegalOrphanMessages = null;
            for (Ecriturec ecriturecCollectionOldEcriturec : ecriturecCollectionOld) {
                if (!ecriturecCollectionNew.contains(ecriturecCollectionOldEcriturec)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Ecriturec " + ecriturecCollectionOldEcriturec + " since its idCg field is not nullable.");
                }
            }
            for (Budgetcgpb budgetcgpbCollectionOldBudgetcgpb : budgetcgpbCollectionOld) {
                if (!budgetcgpbCollectionNew.contains(budgetcgpbCollectionOldBudgetcgpb)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Budgetcgpb " + budgetcgpbCollectionOldBudgetcgpb + " since its compteg field is not nullable.");
                }
            }
            for (Taxe taxeCollection1OldTaxe : taxeCollection1Old) {
                if (!taxeCollection1New.contains(taxeCollection1OldTaxe)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Taxe " + taxeCollection1OldTaxe + " since its idCg field is not nullable.");
                }
            }
            for (Comptet comptetCollection1OldComptet : comptetCollection1Old) {
                if (!comptetCollection1New.contains(comptetCollection1OldComptet)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Comptet " + comptetCollection1OldComptet + " since its numcgP field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (idTaxeNew != null) {
                idTaxeNew = em.getReference(idTaxeNew.getClass(), idTaxeNew.getIdTaxe());
                compteg.setIdTaxe(idTaxeNew);
            }
            if (numnaturecgNew != null) {
                numnaturecgNew = em.getReference(numnaturecgNew.getClass(), numnaturecgNew.getNumnaturecg());
                compteg.setNumnaturecg(numnaturecgNew);
            }
            if (idCrNew != null) {
                idCrNew = em.getReference(idCrNew.getClass(), idCrNew.getIdCr());
                compteg.setIdCr(idCrNew);
            }
            Collection<Comptea> attachedCompteaCollectionNew = new ArrayList<Comptea>();
            for (Comptea compteaCollectionNewCompteaToAttach : compteaCollectionNew) {
                compteaCollectionNewCompteaToAttach = em.getReference(compteaCollectionNewCompteaToAttach.getClass(), compteaCollectionNewCompteaToAttach.getIdCa());
                attachedCompteaCollectionNew.add(compteaCollectionNewCompteaToAttach);
            }
            compteaCollectionNew = attachedCompteaCollectionNew;
            compteg.setCompteaCollection(compteaCollectionNew);
            Collection<Comptet> attachedComptetCollectionNew = new ArrayList<Comptet>();
            for (Comptet comptetCollectionNewComptetToAttach : comptetCollectionNew) {
                comptetCollectionNewComptetToAttach = em.getReference(comptetCollectionNewComptetToAttach.getClass(), comptetCollectionNewComptetToAttach.getIdCt());
                attachedComptetCollectionNew.add(comptetCollectionNewComptetToAttach);
            }
            comptetCollectionNew = attachedComptetCollectionNew;
            compteg.setComptetCollection(comptetCollectionNew);
            Collection<Taxe> attachedTaxeCollectionNew = new ArrayList<Taxe>();
            for (Taxe taxeCollectionNewTaxeToAttach : taxeCollectionNew) {
                taxeCollectionNewTaxeToAttach = em.getReference(taxeCollectionNewTaxeToAttach.getClass(), taxeCollectionNewTaxeToAttach.getIdTaxe());
                attachedTaxeCollectionNew.add(taxeCollectionNewTaxeToAttach);
            }
            taxeCollectionNew = attachedTaxeCollectionNew;
            compteg.setTaxeCollection(taxeCollectionNew);
            Collection<Ecriturec> attachedEcriturecCollectionNew = new ArrayList<Ecriturec>();
            for (Ecriturec ecriturecCollectionNewEcriturecToAttach : ecriturecCollectionNew) {
                ecriturecCollectionNewEcriturecToAttach = em.getReference(ecriturecCollectionNewEcriturecToAttach.getClass(), ecriturecCollectionNewEcriturecToAttach.getIdEc());
                attachedEcriturecCollectionNew.add(ecriturecCollectionNewEcriturecToAttach);
            }
            ecriturecCollectionNew = attachedEcriturecCollectionNew;
            compteg.setEcriturecCollection(ecriturecCollectionNew);
            Collection<Budgetcgpb> attachedBudgetcgpbCollectionNew = new ArrayList<Budgetcgpb>();
            for (Budgetcgpb budgetcgpbCollectionNewBudgetcgpbToAttach : budgetcgpbCollectionNew) {
                budgetcgpbCollectionNewBudgetcgpbToAttach = em.getReference(budgetcgpbCollectionNewBudgetcgpbToAttach.getClass(), budgetcgpbCollectionNewBudgetcgpbToAttach.getBudgetcgpbPK());
                attachedBudgetcgpbCollectionNew.add(budgetcgpbCollectionNewBudgetcgpbToAttach);
            }
            budgetcgpbCollectionNew = attachedBudgetcgpbCollectionNew;
            compteg.setBudgetcgpbCollection(budgetcgpbCollectionNew);
            Collection<Taxe> attachedTaxeCollection1New = new ArrayList<Taxe>();
            for (Taxe taxeCollection1NewTaxeToAttach : taxeCollection1New) {
                taxeCollection1NewTaxeToAttach = em.getReference(taxeCollection1NewTaxeToAttach.getClass(), taxeCollection1NewTaxeToAttach.getIdTaxe());
                attachedTaxeCollection1New.add(taxeCollection1NewTaxeToAttach);
            }
            taxeCollection1New = attachedTaxeCollection1New;
            compteg.setTaxeCollection1(taxeCollection1New);
            Collection<Comptet> attachedComptetCollection1New = new ArrayList<Comptet>();
            for (Comptet comptetCollection1NewComptetToAttach : comptetCollection1New) {
                comptetCollection1NewComptetToAttach = em.getReference(comptetCollection1NewComptetToAttach.getClass(), comptetCollection1NewComptetToAttach.getIdCt());
                attachedComptetCollection1New.add(comptetCollection1NewComptetToAttach);
            }
            comptetCollection1New = attachedComptetCollection1New;
            compteg.setComptetCollection1(comptetCollection1New);
            compteg = em.merge(compteg);
            if (idTaxeOld != null && !idTaxeOld.equals(idTaxeNew)) {
                idTaxeOld.getComptegCollection().remove(compteg);
                idTaxeOld = em.merge(idTaxeOld);
            }
            if (idTaxeNew != null && !idTaxeNew.equals(idTaxeOld)) {
                idTaxeNew.getComptegCollection().add(compteg);
                idTaxeNew = em.merge(idTaxeNew);
            }
            if (numnaturecgOld != null && !numnaturecgOld.equals(numnaturecgNew)) {
                numnaturecgOld.getComptegCollection().remove(compteg);
                numnaturecgOld = em.merge(numnaturecgOld);
            }
            if (numnaturecgNew != null && !numnaturecgNew.equals(numnaturecgOld)) {
                numnaturecgNew.getComptegCollection().add(compteg);
                numnaturecgNew = em.merge(numnaturecgNew);
            }
            if (idCrOld != null && !idCrOld.equals(idCrNew)) {
                idCrOld.getComptegCollection().remove(compteg);
                idCrOld = em.merge(idCrOld);
            }
            if (idCrNew != null && !idCrNew.equals(idCrOld)) {
                idCrNew.getComptegCollection().add(compteg);
                idCrNew = em.merge(idCrNew);
            }
            for (Comptea compteaCollectionOldComptea : compteaCollectionOld) {
                if (!compteaCollectionNew.contains(compteaCollectionOldComptea)) {
                    compteaCollectionOldComptea.getComptegCollection().remove(compteg);
                    compteaCollectionOldComptea = em.merge(compteaCollectionOldComptea);
                }
            }
            for (Comptea compteaCollectionNewComptea : compteaCollectionNew) {
                if (!compteaCollectionOld.contains(compteaCollectionNewComptea)) {
                    compteaCollectionNewComptea.getComptegCollection().add(compteg);
                    compteaCollectionNewComptea = em.merge(compteaCollectionNewComptea);
                }
            }
            for (Comptet comptetCollectionOldComptet : comptetCollectionOld) {
                if (!comptetCollectionNew.contains(comptetCollectionOldComptet)) {
                    comptetCollectionOldComptet.getComptegCollection().remove(compteg);
                    comptetCollectionOldComptet = em.merge(comptetCollectionOldComptet);
                }
            }
            for (Comptet comptetCollectionNewComptet : comptetCollectionNew) {
                if (!comptetCollectionOld.contains(comptetCollectionNewComptet)) {
                    comptetCollectionNewComptet.getComptegCollection().add(compteg);
                    comptetCollectionNewComptet = em.merge(comptetCollectionNewComptet);
                }
            }
            for (Taxe taxeCollectionOldTaxe : taxeCollectionOld) {
                if (!taxeCollectionNew.contains(taxeCollectionOldTaxe)) {
                    taxeCollectionOldTaxe.getComptegCollection().remove(compteg);
                    taxeCollectionOldTaxe = em.merge(taxeCollectionOldTaxe);
                }
            }
            for (Taxe taxeCollectionNewTaxe : taxeCollectionNew) {
                if (!taxeCollectionOld.contains(taxeCollectionNewTaxe)) {
                    taxeCollectionNewTaxe.getComptegCollection().add(compteg);
                    taxeCollectionNewTaxe = em.merge(taxeCollectionNewTaxe);
                }
            }
            for (Ecriturec ecriturecCollectionNewEcriturec : ecriturecCollectionNew) {
                if (!ecriturecCollectionOld.contains(ecriturecCollectionNewEcriturec)) {
                    Compteg oldIdCgOfEcriturecCollectionNewEcriturec = ecriturecCollectionNewEcriturec.getIdCg();
                    ecriturecCollectionNewEcriturec.setIdCg(compteg);
                    ecriturecCollectionNewEcriturec = em.merge(ecriturecCollectionNewEcriturec);
                    if (oldIdCgOfEcriturecCollectionNewEcriturec != null && !oldIdCgOfEcriturecCollectionNewEcriturec.equals(compteg)) {
                        oldIdCgOfEcriturecCollectionNewEcriturec.getEcriturecCollection().remove(ecriturecCollectionNewEcriturec);
                        oldIdCgOfEcriturecCollectionNewEcriturec = em.merge(oldIdCgOfEcriturecCollectionNewEcriturec);
                    }
                }
            }
            for (Budgetcgpb budgetcgpbCollectionNewBudgetcgpb : budgetcgpbCollectionNew) {
                if (!budgetcgpbCollectionOld.contains(budgetcgpbCollectionNewBudgetcgpb)) {
                    Compteg oldComptegOfBudgetcgpbCollectionNewBudgetcgpb = budgetcgpbCollectionNewBudgetcgpb.getCompteg();
                    budgetcgpbCollectionNewBudgetcgpb.setCompteg(compteg);
                    budgetcgpbCollectionNewBudgetcgpb = em.merge(budgetcgpbCollectionNewBudgetcgpb);
                    if (oldComptegOfBudgetcgpbCollectionNewBudgetcgpb != null && !oldComptegOfBudgetcgpbCollectionNewBudgetcgpb.equals(compteg)) {
                        oldComptegOfBudgetcgpbCollectionNewBudgetcgpb.getBudgetcgpbCollection().remove(budgetcgpbCollectionNewBudgetcgpb);
                        oldComptegOfBudgetcgpbCollectionNewBudgetcgpb = em.merge(oldComptegOfBudgetcgpbCollectionNewBudgetcgpb);
                    }
                }
            }
            for (Taxe taxeCollection1NewTaxe : taxeCollection1New) {
                if (!taxeCollection1Old.contains(taxeCollection1NewTaxe)) {
                    Compteg oldIdCgOfTaxeCollection1NewTaxe = taxeCollection1NewTaxe.getIdCg();
                    taxeCollection1NewTaxe.setIdCg(compteg);
                    taxeCollection1NewTaxe = em.merge(taxeCollection1NewTaxe);
                    if (oldIdCgOfTaxeCollection1NewTaxe != null && !oldIdCgOfTaxeCollection1NewTaxe.equals(compteg)) {
                        oldIdCgOfTaxeCollection1NewTaxe.getTaxeCollection1().remove(taxeCollection1NewTaxe);
                        oldIdCgOfTaxeCollection1NewTaxe = em.merge(oldIdCgOfTaxeCollection1NewTaxe);
                    }
                }
            }
            for (Comptet comptetCollection1NewComptet : comptetCollection1New) {
                if (!comptetCollection1Old.contains(comptetCollection1NewComptet)) {
                    Compteg oldNumcgPOfComptetCollection1NewComptet = comptetCollection1NewComptet.getNumcgP();
                    comptetCollection1NewComptet.setNumcgP(compteg);
                    comptetCollection1NewComptet = em.merge(comptetCollection1NewComptet);
                    if (oldNumcgPOfComptetCollection1NewComptet != null && !oldNumcgPOfComptetCollection1NewComptet.equals(compteg)) {
                        oldNumcgPOfComptetCollection1NewComptet.getComptetCollection1().remove(comptetCollection1NewComptet);
                        oldNumcgPOfComptetCollection1NewComptet = em.merge(oldNumcgPOfComptetCollection1NewComptet);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = compteg.getIdCg();
                if (findCompteg(id) == null) {
                    throw new NonexistentEntityException("The compteg with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Compteg compteg;
            try {
                compteg = em.getReference(Compteg.class, id);
                compteg.getIdCg();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The compteg with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<Ecriturec> ecriturecCollectionOrphanCheck = compteg.getEcriturecCollection();
            for (Ecriturec ecriturecCollectionOrphanCheckEcriturec : ecriturecCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Compteg (" + compteg + ") cannot be destroyed since the Ecriturec " + ecriturecCollectionOrphanCheckEcriturec + " in its ecriturecCollection field has a non-nullable idCg field.");
            }
            Collection<Budgetcgpb> budgetcgpbCollectionOrphanCheck = compteg.getBudgetcgpbCollection();
            for (Budgetcgpb budgetcgpbCollectionOrphanCheckBudgetcgpb : budgetcgpbCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Compteg (" + compteg + ") cannot be destroyed since the Budgetcgpb " + budgetcgpbCollectionOrphanCheckBudgetcgpb + " in its budgetcgpbCollection field has a non-nullable compteg field.");
            }
            Collection<Taxe> taxeCollection1OrphanCheck = compteg.getTaxeCollection1();
            for (Taxe taxeCollection1OrphanCheckTaxe : taxeCollection1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Compteg (" + compteg + ") cannot be destroyed since the Taxe " + taxeCollection1OrphanCheckTaxe + " in its taxeCollection1 field has a non-nullable idCg field.");
            }
            Collection<Comptet> comptetCollection1OrphanCheck = compteg.getComptetCollection1();
            for (Comptet comptetCollection1OrphanCheckComptet : comptetCollection1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Compteg (" + compteg + ") cannot be destroyed since the Comptet " + comptetCollection1OrphanCheckComptet + " in its comptetCollection1 field has a non-nullable numcgP field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Taxe idTaxe = compteg.getIdTaxe();
            if (idTaxe != null) {
                idTaxe.getComptegCollection().remove(compteg);
                idTaxe = em.merge(idTaxe);
            }
            Naturecg numnaturecg = compteg.getNumnaturecg();
            if (numnaturecg != null) {
                numnaturecg.getComptegCollection().remove(compteg);
                numnaturecg = em.merge(numnaturecg);
            }
            Compter idCr = compteg.getIdCr();
            if (idCr != null) {
                idCr.getComptegCollection().remove(compteg);
                idCr = em.merge(idCr);
            }
            Collection<Comptea> compteaCollection = compteg.getCompteaCollection();
            for (Comptea compteaCollectionComptea : compteaCollection) {
                compteaCollectionComptea.getComptegCollection().remove(compteg);
                compteaCollectionComptea = em.merge(compteaCollectionComptea);
            }
            Collection<Comptet> comptetCollection = compteg.getComptetCollection();
            for (Comptet comptetCollectionComptet : comptetCollection) {
                comptetCollectionComptet.getComptegCollection().remove(compteg);
                comptetCollectionComptet = em.merge(comptetCollectionComptet);
            }
            Collection<Taxe> taxeCollection = compteg.getTaxeCollection();
            for (Taxe taxeCollectionTaxe : taxeCollection) {
                taxeCollectionTaxe.getComptegCollection().remove(compteg);
                taxeCollectionTaxe = em.merge(taxeCollectionTaxe);
            }
            em.remove(compteg);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Compteg> findComptegEntities() {
        return findComptegEntities(true, -1, -1);
    }

    public List<Compteg> findComptegEntities(int maxResults, int firstResult) {
        return findComptegEntities(false, maxResults, firstResult);
    }

    private List<Compteg> findComptegEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Compteg.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Compteg findCompteg(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Compteg.class, id);
        } finally {
            em.close();
        }
    }

    public int getComptegCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Compteg> rt = cq.from(Compteg.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
